﻿using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using BussinessLogicTecnoPez.Produccion.Clasificacion_e_Incubacion;
using BussinessLogicTecnoPez.Produccion.Compras;
using Tecnopez.Globals;
using System.Collections.Generic;
using WebChart;
using System.Drawing;
using BussinessLogicTecnoPez.Tipos_Comunes;
using BussinessLogicTecnoPez;

public partial class Modules_ClasificacionIncubacion_RegistrarClasificacionDeEstanques : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        GenericMasterPage master = (GenericMasterPage)Master;
        master.Imagen = "../Styles/Icons/kchart.png";
        master.Titulo = "Registrar clasificación de estanques.";
        popEstanqueDestino.ObjType = typeof(Estanque);
        popEstanqueDestino.personalizarGestorAntesDelGetAll(filtrarEstanquesDestinos);
        btnRegistrarClasificacion.OnClientClick = "if(!confirm('¿Esta seguro que desea registrar estas clasificaciónes?')) return false;";
        if (!IsPostBack)
        {
            inicializarPaginaPrimeraVez();
        }

    }

    private void inicializarPaginaPrimeraVez()
    {
        multiPrincipal.SetActiveView(viewSeleccion);
        inicializarGrillaPlanes();
        inicializarGrillaLotes();
        Estanque.getManager.AddFilter("baja", GenericManager<Estanque>.filterOperator.Equals, "N");
        Estanque.getManager.AddFilter("habilitado", GenericManager<Estanque>.filterOperator.Equals, true);
        Estanque.getManager.AddFilter("tipoDeEstanqueInt", GenericManager<Estanque>.filterOperator.Equals, (int)Estanque.tipoEstanque.estCrianza);
        cboClasificacionesNoProgramadas.DataValueField = "idEstanque";
        cboClasificacionesNoProgramadas.DataTextField = "descripcionEnLinea";
        cboClasificacionesNoProgramadas.DataSource = Estanque.getManager.GetFilter();
        cboClasificacionesNoProgramadas.DataBind();

        cboClase.DataSource = claseDeLote.getManager.GetAll();
        cboClase.DataTextField = "Descripcion";
        cboClase.DataValueField = "idClaseDeLote";
        cboClase.DataBind();

        dtFecha.Text = DateTime.Now.ToShortDateString();

        retirarDeSesionClasificacion();
    }

    private class estanquesDeIncubacionXLotes
    {

        public estanquesDeIncubacionXLotes(Estanque paramEstanque, LoteOva paramLote)
        {
            estanque = paramEstanque;
            loteOva = paramLote;
        }

        private Estanque estanque;

        [FriendlyName("Estanque de incubación", true)]
        public Estanque Estanque
        {
            get { return estanque; }
            set { estanque = value; }
        }

        private LoteOva loteOva;

        [FriendlyName("Lote de ova", true)]
        public LoteOva LoteOva
        {
            get { return loteOva; }
            set { loteOva = value; }
        }

        private Especie especie;

        [FriendlyName("Especie", true)]
        public Especie Especie
        {
            get { return loteOva.Especie; }

        }

        [FriendlyName("Cantidad", true)]
        private int cantidadLoteOva
        {
            get
            {
                return loteOva.Cantidad;
            }
        }

        [FriendlyName("Fecha de ingreso", true)]
        private DateTime fechaLoteOva
        {
            get
            {
                return loteOva.FechaIngreso;
            }
        }
    }

    private List<estanquesDeIncubacionXLotes> listaDeEstanquesDeIncubacion
    {
        get
        {
            List<estanquesDeIncubacionXLotes> lista;
            if (Session["estanquesIncubacion"] == null)
            {
                lista = new List<estanquesDeIncubacionXLotes>();
                Session["estanquesIncubacion"] = lista;
            }
            else
            {
                lista = Session["estanquesIncubacion"] as List<estanquesDeIncubacionXLotes>;
            }
            return lista;
        }

        set
        {
            Session["estanquesIncubacion"] = value;
        }
    }

    private void inicializarGrillaLotes()
    {
        DataControlField[] controlesExtra = new DataControlField[1];
        ButtonField b = new ButtonField();
        b.CommandName = "seleccionar";
        b.Text = "Seleccionar";
        b.HeaderText = "";
        b.ImageUrl = Functions.getHost(this.Page) + "Styles/Icons/lupa.png";
        b.ButtonType = ButtonType.Image;

        controlesExtra[0] = b;

        grdLotesListos.setupGrid(typeof(estanquesDeIncubacionXLotes), cargarGrillaDeLotes, true, false, ViewState, controlesExtra);
    }
    private void cargarGrillaDeLotes()
    {
        List<LoteOva> listosParaClasificar = Clasificacion.obtenerLotesListosParaClasificar();
        this.listaDeEstanquesDeIncubacion = new List<estanquesDeIncubacionXLotes>();

        foreach (LoteOva lote in listosParaClasificar)
        {
            List<Estanque> estanquesDelLote = lote.obtenerEstanquesDeIncubacion();
            foreach (Estanque est in estanquesDelLote)
            {
                estanquesDeIncubacionXLotes it = new estanquesDeIncubacionXLotes(est, lote);
                Clasificacion clase = new Clasificacion();
                if (clase.obtenerUltima(est.idEstanque))
                {
                    if (clase.totalEnEstanque > 0)
                    {
                        listaDeEstanquesDeIncubacion.Add(it);
                    }
                }
            }
        }
        grdLotesListos.DataSource = this.listaDeEstanquesDeIncubacion;
        grdLotesListos.DataBind();
    }
    private void inicializarGrillaPlanes()
    {
        DataControlField[] controlesExtra = new DataControlField[1];
        ButtonField b = new ButtonField();
        b.CommandName = "seleccionar";
        b.Text = "Seleccionar";
        b.HeaderText = "";
        b.ImageUrl = Functions.getHost(this.Page) + "Styles/Icons/lupa.png";
        b.ButtonType = ButtonType.Image;

        controlesExtra[0] = b;
        grdPlanes.setupGrid(typeof(PlanDeClasificacion), cargarGrillaDePlanes, true, false, ViewState, controlesExtra);
    }

    private void cargarGrillaDePlanes()
    {

        grdPlanes.DataSource = PlanDeClasificacion.planesConClasificacionesPendientes();
        grdPlanes.DataBind();
    }

    private void filtrarEstanquesDestinos(object parametro)
    {

        int[] array = Estanque.obtenerEstanquesDestinos(this.miClasificacion.estanqueOrigen, this.miClasificacion.cantidadAClasificar).ToArray();

        GenericManager<Estanque> manager = parametro as GenericManager<Estanque>;
        manager.AddFilterIN("idestanque", array);

    }

    protected void grdLotesListos_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        inicializarGrillaPlanes();
        inicializarGrillaLotes();
        if (grdLotesListos.Rows[0].Cells[0].Text == "&nbsp;")
        {
            return;
        }

        estanquesDeIncubacionXLotes item = listaDeEstanquesDeIncubacion[Convert.ToInt32(e.CommandArgument)];
        if (item != null)
        {
            modoClasificación(modosDeOrigen.loteDeOva, item.Estanque, item.LoteOva, null);
        }
        else
        {
            lblErrorViewSeleccion.Text = "No se púdo obtener el lote de ova.";
        }


    }

    protected void grdPlanes_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        inicializarGrillaPlanes();
        if (grdPlanes.Rows[0].Cells[0].Text == "&nbsp;")
        {
            return;
        }
        PlanDeClasificacion objPlan = PlanDeClasificacion.getManager.GetOneByPrimaryKey(grdPlanes.DataKeys[Convert.ToInt32(e.CommandArgument)].Value);
        if (objPlan != null)
        {
            modoClasificación(modosDeOrigen.clasificacionProgramada, objPlan.Estanque, null, objPlan);
        }
        else
        {
            lblErrorViewSeleccion.Text = "No se pudo seleccionar el plan";
        }
    }

    private enum modosDeOrigen
    {
        loteDeOva,
        clasificacionProgramada,
        clasificacionNoProgramada
    }

    private class clasificacionWeb
    {
        public modosDeOrigen modo;
        public Estanque estanqueOrigen;
        public LoteOva loteOrigen;
        public PlanDeClasificacion planDeClasif;
        public Clasificacion ultimaClasificacionOrigen;
        public List<Clasificacion> clasificacionesDestino;
        public int cantidadAClasificar;

    }

    private clasificacionWeb miClasificacion
    {
        get
        {
            return Session["miClasific"] as clasificacionWeb;
        }
        set
        {
            if (value != null)
            {
                Session["miClasific"] = value;
            }
        }
    }

    private void retirarDeSesionClasificacion()
    {
        Session.Remove("miClasific");
    }
    private void guardarEnSesionClasificacion(clasificacionWeb parametro)
    {
        Session["miClasific"] = parametro;
    }

    private void modoClasificación(modosDeOrigen modo, Estanque estanqueOrigen, LoteOva loteOrigen, PlanDeClasificacion planDeClasific)
    {
        lblCodigoEstanque.Text = estanqueOrigen.idEstanque.ToString();
        lblUbicacion.Text = estanqueOrigen.ubicacion.ToString();
        lblCapacidad.Text = estanqueOrigen.capacidad.ToString();

        lblTipoEstanque.Text = estanqueOrigen.tipoDeEstanqueDesc;
        Clasificacion ultimaClas = new Clasificacion();

        if (ultimaClas.obtenerUltima(estanqueOrigen.idEstanque))
        {
            if (ultimaClas.especie != null)
            {
                lblEspecie.Text = ultimaClas.especie.nombre;
                if (ultimaClas.tamanio >= Convert.ToDouble(ultimaClas.especie.tamanomaximo) ||
                    ultimaClas.peso >= Convert.ToDouble(ultimaClas.especie.pesoMaximo))
                {
                    lblSugerencia.Text = "Este estanque esta listo para el faenamiento.";
                }
                else
                {
                    lblSugerencia.Text = "";
                }
            }
            else
            {
                lblEspecie.Text = "";
            }
            lblCantEstanque.Text = ultimaClas.totalEnEstanque.ToString();
            lblTamanio.Text = ultimaClas.tamanio.ToString();
            lblPesoMedio.Text = ultimaClas.peso.ToString();
            if (ultimaClas.claseDeLote != null)
            {
                lblClaseDeLote.Text = ultimaClas.claseDeLote.Descripcion;
            }
            else
            {
                lblClaseDeLote.Text = "";
            }
        }
        else
        {
            lblEspecie.Text = "";
            lblCantEstanque.Text = "";
            lblTamanio.Text = "";
            lblPesoMedio.Text = "";
            lblClaseDeLote.Text = "";
            lblSugerencia.Text = "";
        }

        if (loteOrigen != null)
        {
            lblLote.Text = loteOrigen.ToString();
        }
        else
        {
            lblLote.Text = "Varios lotes.";
        }

        if (planDeClasific != null)
        {
            lblPlanDeClasificacion.Text = planDeClasific.IdPlanDeClasificacion.ToString();
        }
        else
        {
            lblPlanDeClasificacion.Text = "No programada.";
        }

        clasificacionWeb miClasif = new clasificacionWeb();
        miClasif.estanqueOrigen = estanqueOrigen;
        miClasif.loteOrigen = loteOrigen;
        miClasif.modo = modo;
        miClasif.planDeClasif = planDeClasific;
        miClasif.ultimaClasificacionOrigen = ultimaClas;
        miClasif.clasificacionesDestino = new List<Clasificacion>();
        if (ultimaClas != null)
        {
            miClasif.cantidadAClasificar = ultimaClas.totalEnEstanque;
        }
        else
        {
            miClasif.cantidadAClasificar = 0;
        }
        this.miClasificacion = miClasif;

        lblRestanPorClasificar.Text = miClasif.cantidadAClasificar.ToString();

        inicializarGrillaClasificaciones();
        inicializarGrafico();

        multiPrincipal.SetActiveView(viewClasificacion);

    }

    private void inicializarGrillaClasificaciones()
    {
        DataControlField[] d = new DataControlField[1];
        ButtonField colC = new ButtonField();
        colC.ButtonType = ButtonType.Image;

        colC.CommandName = "quitar";
        colC.HeaderText = "Quitar";


        d[0] = colC;

        grdClasificaciones.setupGrid(typeof(Clasificacion), cargarGrillaClasificacion, false, false, ViewState, d);
    }

    private void cargarGrillaClasificacion()
    {
        grdClasificaciones.DataSource = this.miClasificacion.clasificacionesDestino;
        grdClasificaciones.DataBind();
    }

    /// <summary>
    /// Seleccion de no programada.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Button1_Click(object sender, EventArgs e)
    {
        if (cboClasificacionesNoProgramadas.SelectedItem == null)
        {
            lblErrorViewSeleccion.Text = "No hay estanques disponibles para clasificaciones no programadas";
            return;
        }
        Int32 idEstanque = Convert.ToInt32(cboClasificacionesNoProgramadas.SelectedValue);
        Estanque objEstanque = Estanque.getManager.GetOneByPrimaryKey(idEstanque);
        if (objEstanque != null)
        {
            modoClasificación(modosDeOrigen.clasificacionNoProgramada, objEstanque, null, null);
        }
        else
        {
            lblErrorViewSeleccion.Text = "No se pudo seleccionar ese estanque sucedió: " + Estanque.getManager.GeneratedException.ToString();
        }
    }

    protected void grdClasificaciones_RowDataBound(object sender, GridViewRowEventArgs e)
    {
        if (e.Row.Cells.Count < 6) return;
        if (e.Row.Cells[6].Controls.Count == 0) return;
        ImageButton img = (ImageButton)e.Row.Cells[6].Controls[0];
        img.ImageUrl = Functions.getHost(this.Page) + "Styles/Icons/eliminar.gif";
        img.ToolTip = "Presione aqui para eliminar.";
        img.CommandArgument = e.Row.RowIndex.ToString();
        if (e.Row.Cells[0].Text == "&nbsp;")
        {
            img.OnClientClick = "alert('Este elemento no puede ser eliminado'); return false;";
        }
        else
        {
            img.OnClientClick = "if(!confirm('¿Seguro que desea quitar este elemento?')){ return false;}";
        }
    }



    private void agregarClasificaciones()
    {
        inicializarGrillaClasificaciones();
        inicializarGrafico();
        if (popEstanqueDestino.ItemSelected == null)
        {
            lblErrorClasificacion.Text = "Por favor seleccione un estanque destino.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }
        if (!this.IsValid)
        {
            lblErrorClasificacion.Text = "Verifique los datos ingresados.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }
        int totalEntrante = Convert.ToInt32(txtCantidad.Text);
        decimal tamanioEntrante = Convert.ToDecimal(txtTamanio.Text);
        decimal pesoEntrante = Convert.ToDecimal(txtPesoMedio.Text);
        int tamanioMuestraEntrante = Convert.ToInt32(txtTamanioMuestra.Text);

        int idClaseDeLote = Convert.ToInt32(cboClase.SelectedValue);
        claseDeLote claseDeLote = claseDeLote.getManager.GetOneByPrimaryKey(idClaseDeLote);
        if (claseDeLote == null)
        {
            lblErrorClasificacion.Text = "La clase de lote seleccionada no es válida.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }
        Estanque estanqueDestino = popEstanqueDestino.ItemSelected as Estanque;
        Clasificacion clasifEstanqueDestino = new Clasificacion();
        if (clasifEstanqueDestino.obtenerUltima(estanqueDestino.idEstanque)
                && clasifEstanqueDestino.totalEnEstanque > 0)
        {
            if (clasifEstanqueDestino.idClaseDeLote != idClaseDeLote)
            {
                lblErrorClasificacion.Text = "El estanque destino seleccionado solo admite peces de clase: " + clasifEstanqueDestino.claseDeLote.Descripcion + " por favor verifique los datos.";
                Functions.MessageBox(lblErrorClasificacion.Text, this);
                return;
            }
            else
            {
                if (this.miClasificacion.ultimaClasificacionOrigen != null &&
                    clasifEstanqueDestino.idEspecie != this.miClasificacion.ultimaClasificacionOrigen.idEspecie)
                {
                    lblErrorClasificacion.Text = "La especie en el estanque destino es diferente al del estanque origen.";
                    Functions.MessageBox(lblErrorClasificacion.Text, this);
                    return;
                }
            }

        }



        long capacidadDisponible = estanqueDestino.capacidad - clasifEstanqueDestino.totalEnEstanque;
        if (capacidadDisponible < totalEntrante)
        {
            lblErrorClasificacion.Text = "La capacidad disponible del estanque destino es de hasta:" + capacidadDisponible;
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }

        if (this.miClasificacion.ultimaClasificacionOrigen == null)
        {
            lblErrorClasificacion.Text = "No hay peces en el estanque origen.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }
        if (this.miClasificacion.cantidadAClasificar < totalEntrante)
        {
            lblErrorClasificacion.Text = "No hay " + totalEntrante.ToString()
                                            + " peces para clasificar en el estanque origen. Ya que dispone de solo "
                                            + this.miClasificacion.ultimaClasificacionOrigen.totalEnEstanque.ToString()
                                            + " restantes, para clasificar.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }

        if (tamanioMuestraEntrante > totalEntrante)
        {
            lblErrorClasificacion.Text = "El tamaño de la muestra no puede superar a la cantidad entrante de peces.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }

        DateTime fecha;
        if (dtFecha.Text.Trim() == string.Empty)
        {
            lblErrorClasificacion.Text = "Por favor ingrese una fecha válida.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }
        if (!DateTime.TryParse(dtFecha.Text, out fecha))
        {
            lblErrorClasificacion.Text = "La fecha ingresada no es válida.";
            Functions.MessageBox(lblErrorClasificacion.Text, this);
            return;
        }

        foreach (Clasificacion clasCEnLista in miClasificacion.clasificacionesDestino)
        {
            if (clasCEnLista.estanqueDestino.idEstanque == estanqueDestino.idEstanque)
            {
                lblErrorClasificacion.Text = "El estanque destino seleccionado ya se encuentra en la clasifiación. Si desea modificar los valores de la misma retirelo y vuelva a incorporarlo.";
                Functions.MessageBox(lblErrorClasificacion.Text, this);
                return;
            }
        }

        List<PlanDeClasificacion> planesDelDestino = PlanDeClasificacion.planesConClasificacionesPendientes(estanqueDestino.idEstanque);
        foreach (PlanDeClasificacion planDestino in planesDelDestino)
        {
            if (this.miClasificacion.ultimaClasificacionOrigen.especie.idespecie != planDestino.Especie.idespecie)
            {
                lblErrorClasificacion.Text = "El estanque destino tiene planificaciones pendientes para la especie: " + planDestino.Especie.nombre + ". No puede mezclar especies seleccione otro estanque destino.";
                Functions.MessageBox(lblErrorClasificacion.Text, this);
                return;
            }
        }

        Clasificacion nuevaClasificacion = new Clasificacion();

        nuevaClasificacion.cantidadEntrante = totalEntrante;
        nuevaClasificacion.claseDeLote = claseDeLote;
        nuevaClasificacion.especie = this.miClasificacion.ultimaClasificacionOrigen.especie;
        nuevaClasificacion.estanqueDestino = estanqueDestino;
        nuevaClasificacion.estanqueOrigen = this.miClasificacion.estanqueOrigen;
        nuevaClasificacion.fecha = fecha;
        nuevaClasificacion.peso = Convert.ToDouble(pesoEntrante);
        nuevaClasificacion.tamanio = Convert.ToDouble(tamanioEntrante);
        nuevaClasificacion.TamanioMuestra = tamanioMuestraEntrante;
        nuevaClasificacion.cantidadEntrante = totalEntrante;

        if (miClasificacion.planDeClasif != null)
        {
            nuevaClasificacion.idPlanClasificacion = miClasificacion.planDeClasif.IdPlanDeClasificacion;
        }


        this.miClasificacion.clasificacionesDestino.Add(nuevaClasificacion);
        miClasificacion.cantidadAClasificar = miClasificacion.cantidadAClasificar - totalEntrante;
        lblRestanPorClasificar.Text = miClasificacion.cantidadAClasificar.ToString();

        this.guardarEnSesionClasificacion(this.miClasificacion);

        cargarGrillaClasificacion();

        limpiarFormulario();

    }

    private void limpiarFormulario()
    {
        lblErrorClasificacion.Text = "";
        txtCantidad.Text = "";
        txtPesoMedio.Text = "";
        txtTamanio.Text = "";
        txtTamanioMuestra.Text = "";
        popEstanqueDestino.ItemSelected = null;

    }

    protected void grdClasificaciones_RowCommand(object sender, GridViewCommandEventArgs e)
    {

        if (e.CommandName == "quitar")
        {
            Int32 indice = Convert.ToInt32(e.CommandArgument);
            Clasificacion clasiDest = this.miClasificacion.clasificacionesDestino[indice];
            this.miClasificacion.cantidadAClasificar += clasiDest.cantidadEntrante;
            lblRestanPorClasificar.Text = this.miClasificacion.cantidadAClasificar.ToString();
            this.miClasificacion.clasificacionesDestino.RemoveAt(indice);
            guardarEnSesionClasificacion(this.miClasificacion);
            inicializarGrillaClasificaciones();
            inicializarGrafico();
        }
    }

    private void inicializarGrafico()
    {
        //ColumnChart chart = new ColumnChart();
        //chart.Fill.Color = Color.FromArgb(50, Color.SteelBlue);
        //chart.Line.Color = Color.SteelBlue;
        //chart.Line.Width = 2;

        PieChart chart = new PieChart();
        chart.ShowLegend = true;
        chart.Shadow.Color = Color.Gray;
        chart.Shadow.Visible = true;
        chart.ShowLineMarkers = true;



        chart.Legend = "Distribución de lote de ovas.";

        if (miClasificacion.ultimaClasificacionOrigen != null)
        {
            foreach (detalleClasificacion det in miClasificacion.ultimaClasificacionOrigen.detalle)
            {
                chart.Data.Add(new ChartPoint(
                    det.loteDeOva.Codigo + " " +
                    (Math.Round(det.proporcion * 100)).ToString() + "%",
                    (float)det.proporcion * 100));
            }
        }

        ConfigureColors(chartDistribucion);
        chartDistribucion.Charts.Add(chart);
        chartDistribucion.RedrawChart();
    }

    private static void ConfigureColors(ChartControl ChartControlToSetup)
    {
        ChartControlToSetup.Background.Color = Color.FromArgb(75, Color.SteelBlue);
        ChartControlToSetup.Background.Type = InteriorType.LinearGradient;
        ChartControlToSetup.Background.ForeColor = Color.SteelBlue;
        ChartControlToSetup.Background.EndPoint = new Point(500, 568);
        ChartControlToSetup.Legend.Position = LegendPosition.Bottom;
        //ChartControlToSetup.Legend.Width = 40;

        ChartControlToSetup.GridLines = WebChart.GridLines.None;


        //ChartControlToSetup.YAxisFont.ForeColor = Color.SteelBlue;
        //ChartControlToSetup.XAxisFont.ForeColor = Color.SteelBlue;

        ChartControlToSetup.ChartTitle.Text = "Distribución de lotes de ovas.";
        ChartControlToSetup.ChartTitle.ForeColor = Color.Black;



        ChartControlToSetup.Border.Color = Color.SteelBlue;
        ChartControlToSetup.BorderStyle = BorderStyle.Ridge;

    }

    protected void btnAgregarClasificaciones_Click(object sender, EventArgs e)
    {
        agregarClasificaciones();
    }
    protected void btnCancelarClasificacion_Click(object sender, EventArgs e)
    {
        //Saco los datos.
        volverPaginaAlPrincipio();
    }

    private void volverPaginaAlPrincipio()
    {
        retirarDeSesionClasificacion();
        inicializarPaginaPrimeraVez();
        limpiarFormulario();
        multiPrincipal.SetActiveView(viewSeleccion);
    }

    /// <summary>
    /// Metodo de resgistracion de clasificacion.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnRegistrarClasificacion_Click(object sender, EventArgs e)
    {
        double tamanioActual;
        double pesoActual;
        if (!double.TryParse(txtTamanioMedioActual.Text, out tamanioActual)
            || !double.TryParse(txtPesoMedioActual.Text, out pesoActual))
        {
            Functions.MessageBox("Los datos de peso y tamaño actual no son optativos.", this);
            return;
        }
        inicializarGrillaClasificaciones();
        inicializarGrafico();
        if (this.miClasificacion == null)
        {
            Functions.MessageBox("Se perdio la información de sesion. Vuelva a seleccionar la opción 'registrar clasificación' desde el menú para volver a intentarlo.", this);
            return;
        }
        if (this.miClasificacion.clasificacionesDestino.Count == 0)
        {
            Functions.MessageBox("Al menos ingrese una clasificación, para poder completar la registración.", this);
            return;
        }

        using (System.Transactions.TransactionScope transaccion = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.RequiresNew, new TimeSpan(0, 30, 0)))
        {
            //por cada clasificacion hacer...
            foreach (Clasificacion clase in this.miClasificacion.clasificacionesDestino)
            {
                if (!clase.clasificar(pesoActual, tamanioActual))
                {
                    Functions.MessageBox("Se produjo un error al intentar clasificar.", this);
                    return;
                }

            }

            //Si vino de un plan actualizarlo.
            if (this.miClasificacion.planDeClasif != null)
            {
                if (!this.miClasificacion.planDeClasif.actualizarEjecucionDelPlan(miClasificacion.clasificacionesDestino[0].fecha, tamanioActual, pesoActual))
                {
                    Functions.MessageBox("Se produjo un error al actualizar el plan de clasificación.", this);
                    return;
                }
            }

            //si tenemos el lote no olvidar el cambio de estado....
            if (this.miClasificacion.loteOrigen != null)
            {
                //Si todas las ovas fueron clasificadas
                //se produce entonces un cambio de estado a "Clasificado" y ya no se mostrara
                //en la grilla por esta razón.
                if (this.miClasificacion.cantidadAClasificar == 0)
                {
                    List<Estanque> estanquesDeIncubacion = this.miClasificacion.loteOrigen.obtenerEstanquesDeIncubacion();
                    Boolean esTiempoDeCambiarEstado = true;
                    foreach (Estanque it in estanquesDeIncubacion)
                    {
                        Clasificacion ultimadeIt = new Clasificacion();
                        if (ultimadeIt.obtenerUltima(it.idEstanque))
                        {
                            if (ultimadeIt.totalEnEstanque != 0)
                            {
                                esTiempoDeCambiarEstado = false;
                            }
                        }

                    }
                    if (esTiempoDeCambiarEstado)
                    {
                        TipoEstadoLoteOvas estadoClasificado;
                        TipoEstadoLoteOvas.getManager.ClearFilters();
                        TipoEstadoLoteOvas.getManager.AddFilter("IdTipoEstadoLoteOva",
                                    GenericManager<TipoEstadoLoteOvas>.filterOperator.Equals,
                                    (int)TipoEstadoLoteOvas.estadosLoteOva.Clasificado);
                        estadoClasificado = TipoEstadoLoteOvas.getManager.GetOne();
                        this.miClasificacion.loteOrigen.TipoEstadoLoteOva = estadoClasificado;
                        if (!LoteOva.getManager.Update(this.miClasificacion.loteOrigen))
                        {
                            Functions.MessageBox("No se pudo cambiar el estado del lote de ovas. \n" + LoteOva.getManager.GeneratedException.ToString(), this);
                            return;
                        }
                    }
                }
            }


            limpiarFormulario();
            volverPaginaAlPrincipio();
            Functions.MessageBox("La clasificación del estanque fue registrada con éxito.", this);
            transaccion.Complete();
        }
    }

    protected void grdLotesListos_SelectedIndexChanged(object sender, EventArgs e)
    {

    }
}

